In the early days of computers, processors and memory were very expensive to manufacture. Fortunately, the demands that one individual user could put on a processor and memory were small because the user interface was simple, even rudimentary; it consisted of a command line on a display terminal. To accommodate these limitations, computer designers of the day utilized a time-sharing, transaction-based model for computers where multiple users, each at a display terminal, would share one centrally-located processor and memory.
Thus, the centrally located processor (called a "host" or a "server") had multiple display terminals attached to it. The terminals typically contained little more than a display screen, a keyboard, and only enough memory and control circuitry necessary to display information at the terminal and send a screen's worth of data to the host processor in the form of a transaction. Today, we call these terminals "dumb terminals" because they lack a sophisticated processor and memory. The user would typically type one screen's worth of data at the terminal and then send it to the host by hitting an "enter" or a "transmit" key. This data would request the host to perform a transaction. The host would start a transient program to perform the transaction; when the transaction completed, the host would send data back to the terminal and the transient program would end. The host would then forget about the user until the next transaction. If the user submitted multiple transactions to the host, the host transient program did not know that these transactions were related. Likewise, the host did not know when the user was done issuing transactions. Thus, each transient program was self-contained and did not save information from one transient program to the next. This model worked well because the demands of one transaction from one user were very small compared to the processing power of the host, so while the processor was waiting for the user to type information on the screen and send a transaction, the processor would service transactions from other users. Thus, we call this is a time-sharing, transaction-based model.
With the advent of graphical user interfaces--where the user interacts with the computer via images, symbols and graphics--the demands on the central processor increased, so that it could no longer service the needs of a multitude of users, at a multitude of display terminals. Fortunately, the price of processors and memory decreased dramatically, so that users could afford to put a full-fledged computer complete with a sophisticated processor and memory on their desk. But, even with their new-found, desk-top autonomy and processing power, users still want to be connected to a centrally located computer, so that they can share information with friends, co-workers, customers, and suppliers, all scattered around the globe.
One such way to share information is the Internet, which is an example of an interconnected network of computers containing clients and servers. A way to share information on the Internet is via browsing. When a user at a client computer wishes to browse information at a server computer, the user gives a browser at the client an address of the desired document at the server. A document is a file of control-codes and information, which the control-codes describe. The browser at the client transmits this address to the server. The server then transmits the specified document to the client browser, which presents pages of information in the document to the user. A page is the information, as formatted by the browser interpreting the control-codes, that the browser presents to the user. This presentation may occur, for example, visually via the browser window on a display screen or aurally via speakers.
Although most people only first heard of the Internet in the early 1990's, it was actually developed in the 1960's, so it is built on the old, transaction-based computer model. But, today's users don't want to go back to the old model; they don't want to give up their sophisticated graphical user interface and the immediacy of the processing power on their desktop. The following are examples of problems with the transaction-based model.
First, the user does not get immediate feedback about the validity of the data the user enters on the screen. Instead, the user must wait for the client to send the transaction to the server, the server to valididate the data, and the server to send back a message, possibly containing a validity error, to the client.
Second, the user does not get immediate feedback on the actions the user has selected; if the user selects a control button, the user-interface does not indicate that the control button has been selected. This can be a significant usability problem, especially as the number of options on the screen becomes large and the time for the server to respond becomes lengthy.
Third, when the user need help information, the server sends it to the client as a new window, that is the same size as the original window and is overlayed directly on top of the original window. Thus, once the client displays the help window, the user can no longer see the original window, which contains the information about which the user needs the help.
Finally, transactions are not linked togethor. The user may request one piece of information from the server in a first transaction in order to re-enter the data in a request for a second transaction from the user.
For the foregoing reasons, there is a need for a system for communicating between a client and transient server programs.